<script>
	import Vue from 'vue'
	export default {
		onLaunch: function() {
			console.log('App Launch')
			// iOS 首次进入自动刷新
			const isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);
			if (isIOS && !sessionStorage.getItem('iosRefreshed')) {
				sessionStorage.setItem('iosRefreshed', 'true');
				window.location.reload();
				return;
			}

			// 检查登录状态
			this.checkLoginStatus()
			// 添加路由守卫
			uni.addInterceptor('navigateTo', {
				invoke: this.routeGuard.bind(this),
				fail: (err) => {
					console.error('路由拦截失败:', err)
				}
			})
			uni.addInterceptor('redirectTo', {
				invoke: this.routeGuard.bind(this),
				fail: (err) => {
					console.error('路由拦截失败:', err)
				}
			})
			uni.addInterceptor('reLaunch', {
				invoke: this.routeGuard.bind(this),
				fail: (err) => {
					console.error('路由拦截失败:', err)
				}
			})
			uni.addInterceptor('switchTab', {
				invoke: this.routeGuard.bind(this),
				fail: (err) => {
					console.error('路由拦截失败:', err)
				}
			})

			// 添加全局请求拦截器，自动注入 Authorization
			uni.addInterceptor('request', {
				invoke(args) {
					const rawToken = uni.getStorageSync('token')
					// 保证 header 对象存在
					args.header = args.header || {}

					if (rawToken) {
						// 确保带有 Bearer 前缀
						const formatted = rawToken.startsWith('Bearer ') ? rawToken : `Bearer ${rawToken}`
						args.header['Authorization'] = formatted
					} else {
						// 未登录或 token 失效，确保不带 Authorization 头
						if ('Authorization' in args.header) {
							delete args.header['Authorization']
						}
					}
				},
				fail(err) {
					console.error('请求拦截失败:', err)
				}
			})

			uni.getSystemInfo({
				success: function(e) {
					// #ifndef MP
					Vue.prototype.StatusBar = e.statusBarHeight;
					if (e.platform == 'android') {
						Vue.prototype.CustomBar = e.statusBarHeight + 50;
					} else {
						Vue.prototype.CustomBar = e.statusBarHeight + 45;
					};
					// #endif

					// #ifdef MP-WEIXIN
					Vue.prototype.StatusBar = e.statusBarHeight;
					let custom = wx.getMenuButtonBoundingClientRect();
					Vue.prototype.Custom = custom;
					Vue.prototype.CustomBar = custom.bottom + custom.top - e.statusBarHeight;
					// #endif		

					// #ifdef MP-ALIPAY
					Vue.prototype.StatusBar = e.statusBarHeight;
					Vue.prototype.CustomBar = e.statusBarHeight + e.titleBarHeight;
					// #endif
				}
			})

		},
		onShow: function() {
			console.log('App Show')
			// 每次显示应用时检查登录状态
			this.checkLoginStatus()
			// 获取并更新用户位置
			this.updateUserLocation()
		},
		onHide: function() {
			console.log('App Hide')
		},
		methods: {
			// 获取并更新用户位置
			updateUserLocation() {
				// 检查用户是否已登录
				const userInfoStr = uni.getStorageSync('userInfo')
				const token = uni.getStorageSync('token')

				if (!userInfoStr || !token) {
					console.log('用户未登录，不更新位置信息')
					return
				}

				let userInfo = null
				try {
					userInfo = typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr
					if (userInfo.code === 200 && userInfo.data) {
						userInfo = userInfo.data
					}
				} catch (err) {
					console.error('解析用户信息失败:', err)
					return
				}

				// 检查是否有会员ID
				if (!userInfo.memberId) {
					console.log('用户没有会员ID，不更新位置信息')
					return
				}

				// 检查是否已经更新过位置（避免频繁更新）
				const lastLocationUpdate = uni.getStorageSync('lastLocationUpdate')
				const now = Date.now()

				// 如果上次更新时间在30分钟内，则跳过更新
				if (lastLocationUpdate && (now - lastLocationUpdate < 30 * 60 * 1000)) {
					console.log('位置信息已更新，跳过本次更新')
					return
				}

				// 尝试使用微信JSSDK获取位置
				this.getLocationByWxJSSDK(userInfo, token)
			},

			// 使用微信JSSDK获取位置
			getLocationByWxJSSDK(userInfo, token) {
				// 检查是否在微信环境中
				const isWeixin = /MicroMessenger/i.test(navigator.userAgent)
				if (!isWeixin) {
					console.log('非微信环境，使用IP定位');
					this.getLocationByIP(userInfo, token);
					return;
				}

				// 获取当前页面完整URL
				const currentUrl = window.location.href.split('#')[0];
				console.log('当前页面URL:', currentUrl);

				// 先从后端获取jssdk配置
				uni.request({
					url: `${uni.$config.baseUrl}/wx/jssdk/config`,
					method: 'GET',
					data: {
						url: currentUrl
					},
					success: (res) => {
						if (res.statusCode === 200 && res.data.code === 200) {
							const config = res.data.data;

							// 加载jweixin-module
							try {
								const jWeixin = require('jweixin-module');

								// 配置微信JSSDK
								jWeixin.config({
									debug: false,
									appId: config.appId,
									timestamp: config.timestamp,
									nonceStr: config.nonceStr,
									signature: config.signature,
									jsApiList: ['getLocation', 'openLocation']
								});

								// 使用微信JSSDK获取位置
								jWeixin.ready(() => {
									jWeixin.getLocation({
										type: 'gcj02',
										success: (res) => {
											console.log('微信定位成功:', res);
											// 更新位置到服务器
											this.updateLocationToServer(userInfo, token,
												res.latitude, res.longitude);
										},
										fail: (error) => {
											console.error('微信定位失败:', error);
											// 如果微信JSSDK获取位置失败，尝试使用IP定位
											this.getLocationByIP(userInfo, token);
										}
									});
								});

								jWeixin.error((err) => {
									console.error('微信JSSDK配置失败:', err);
									// 如果微信JSSDK配置失败，尝试使用IP定位
									this.getLocationByIP(userInfo, token);
								});
							} catch (error) {
								console.error('加载jweixin-module失败:', error);
								// 如果加载jweixin-module失败，尝试使用IP定位
								this.getLocationByIP(userInfo, token);
							}
						} else {
							// 如果获取配置失败，尝试使用IP定位
							this.getLocationByIP(userInfo, token);
						}
					},
					fail: () => {
						// 如果请求失败，尝试使用IP定位
						this.getLocationByIP(userInfo, token);
					}
				});
			},

			// 使用IP定位
			getLocationByIP(userInfo, token) {
				uni.request({
					url: `${uni.$config.baseUrl}/map/location/v1/ip`,
					method: 'GET',
					data: {
						key: 'GJZBZ-5ZV6G-ID2QK-Q6ODP-WNIPQ-HZFB4'
					},
					success: (res) => {
						if (res.data.code === 200) {
							const locationData = res.data.data;
							console.log('IP定位成功:', locationData);

							// 从IP定位结果中获取经纬度
							const latitude = locationData.location.lat;
							const longitude = locationData.location.lng;

							// 更新位置到服务器
							this.updateLocationToServer(userInfo, token, latitude, longitude);
						} else {
							console.error('IP定位失败:', res.data);
							// 如果IP定位失败，尝试使用浏览器定位
							this.getLocationByBrowser(userInfo, token);
						}
					},
					fail: (err) => {
						console.error('请求IP定位接口失败:', err);
						// 如果IP定位请求失败，尝试使用浏览器定位
						this.getLocationByBrowser(userInfo, token);
					}
				});
			},

			// 使用浏览器原生定位
			getLocationByBrowser(userInfo, token) {
				if (navigator.geolocation) {
					navigator.geolocation.getCurrentPosition(
						(position) => {
							const latitude = position.coords.latitude
							const longitude = position.coords.longitude

							console.log('浏览器定位成功:', {
								latitude,
								longitude
							})
							this.updateLocationToServer(userInfo, token, latitude, longitude)
						},
						(error) => {
							console.error('浏览器定位失败:', error)

							// 如果所有定位方式都失败，使用默认位置
							if (userInfo.latitude && userInfo.longitude) {
								console.log('使用上次保存的位置信息')
								this.updateLocationToServer(userInfo, token, userInfo.latitude, userInfo.longitude)
							} else {
								console.log('无法获取位置信息，跳过更新')
							}
						}, {
							enableHighAccuracy: true,
							timeout: 5000,
							maximumAge: 0
						}
					)
				} else {
					console.log('浏览器不支持定位')

					// 如果浏览器不支持定位，使用默认位置
					if (userInfo.latitude && userInfo.longitude) {
						console.log('使用上次保存的位置信息')
						this.updateLocationToServer(userInfo, token, userInfo.latitude, userInfo.longitude)
					} else {
						console.log('无法获取位置信息，跳过更新')
					}
				}
			},

			// 更新位置到服务器
			updateLocationToServer(userInfo, token, latitude, longitude) {
				// 判断用户类型，如果是技师则调用技师位置更新接口
				if (userInfo.techId) {
					// 更新技师位置
					uni.request({
						url: `${uni.$config.baseUrl}/technician/technician/updateLocation/${userInfo.techId}`,
						method: 'PUT',
						header: {
							'Content-Type': 'application/json',
							'Authorization': token
						},
						data: {
							latitude: latitude,
							longitude: longitude
						},
						success: (response) => {
							console.log('更新技师位置成功:', response);
							if (response.statusCode === 200 && response.data.code === 200) {
								// 更新本地存储的用户信息
								const updatedTech = response.data.data;

								// 构建新的userInfo对象
								const newUserInfo = {
									...userInfo,
									// 添加位置信息
									latitude: updatedTech.latitude,
									longitude: updatedTech.longitude
								};

								// 更新本地存储
								uni.setStorageSync('userInfo', newUserInfo);

								// 记录更新时间
								uni.setStorageSync('lastLocationUpdate', Date.now());

								console.log('已更新本地技师位置信息');
							} else {
								console.error('更新技师位置失败:', response.data);
							}
						},
						fail: (err) => {
							console.error('请求更新技师位置失败:', err);
						}
					});
				} else {
					// 更新会员位置
					uni.request({
						url: `${uni.$config.baseUrl}/member/member/updateLocation/${userInfo.memberId}`,
						method: 'PUT',
						header: {
							'Content-Type': 'application/json',
							'Authorization': token
						},
						data: {
							latitude: latitude,
							longitude: longitude
						},
						success: (response) => {
							console.log('更新会员位置成功:', response);
							if (response.statusCode === 200 && response.data.code === 200) {
								// 更新本地存储的用户信息
								const updatedMember = response.data.data;

								// 构建新的userInfo对象
								const newUserInfo = {
									nickname: userInfo.nickname || '',
									realName: userInfo.realName || '',
									avatarUrl: userInfo.avatarUrl || '',
									gender: userInfo.gender || 0,
									phone: userInfo.phone || '',
									memberNo: userInfo.memberNo || '',
									memberId: userInfo.memberId || '',
									openId: userInfo.openId || '',
									techId: userInfo.techId || '',
									birthday: userInfo.birthday || '',
									totalPoints: userInfo.totalPoints || 0,
									availablePoints: userInfo.availablePoints || 0,
									totalAmount: userInfo.totalAmount || 0,
									memberLevel: userInfo.memberLevel || 0,
									role: userInfo.techId !== '' ? 'technician' : 'customer',
									// 添加位置信息
									latitude: updatedMember.latitude,
									longitude: updatedMember.longitude
								};

								// 更新本地存储
								uni.setStorageSync('userInfo', newUserInfo);

								// 记录更新时间
								uni.setStorageSync('lastLocationUpdate', Date.now());

								console.log('已更新本地用户位置信息');
							} else {
								console.error('更新会员位置失败:', response.data);
							}
						},
						fail: (err) => {
							console.error('请求更新会员位置失败:', err);
						}
					});
				}
			},

			// 路由守卫
			routeGuard(e) {
				const userInfoStr = uni.getStorageSync('userInfo')
				const token = uni.getStorageSync('token')
				let userInfo = null

				if (userInfoStr) {
					try {
						userInfo = typeof userInfoStr === 'string' ? JSON.parse(userInfoStr) : userInfoStr
						if (userInfo.code === 200 && userInfo.data) {
							userInfo = userInfo.data
						}
					} catch (err) {
						console.error('解析用户信息失败:', err)
						return false
					}
				}

				// 白名单页面不需要登录验证
				const whiteList = [
					'/pages/login/login',
					'/pages/login/tech-login',
					'/pages/login/customer-login',
					'/pages/face-valid/face-valid',
					'/pages/address/address',
					'/pages/address/edit-address',
					'/pages/pay-public/pay-public',
					'/pages/my-info/my-info'
				]
				const isWhiteListPage = whiteList.some(page => e.url.includes(page))

				// 允许从登录相关页面互相跳转
				const isLoginRelatedPage = e.url.includes('/pages/login/')
				const currentPage = getCurrentPages()
				const isFromLoginPage = currentPage.length > 0 &&
					(currentPage[currentPage.length - 1].route.includes('login') ||
						currentPage[currentPage.length - 1].route.includes('tech-login') ||
						currentPage[currentPage.length - 1].route.includes('customer-login'))

				if (isLoginRelatedPage && isFromLoginPage) {
					return true
				}
				// 获取当前要跳转的页面类型
				const isTabBarPage = (url) => {
					const tabBarPages = [
						'/pages/technician/home',
						'/pages/technician/time',
						'/pages/technician/order',
						'/pages/technician/message',
						'/pages/technician/my',
						'/pages/index/index',
						'/pages/collaboration/collaboration',
						'/pages/booking-select/booking-select',
						'/pages/project/project',
						'/pages/my/my'
					]
					return tabBarPages.includes(url)
				}

				return true
			},

			goToBooking() {
				uni.navigateTo({
					url: '/pages/booking/booking'
				})
			},

			// 检查登录状态
			checkLoginStatus() {
				console.log('App.vue 检查登录状态')
				// 获取用户信息和token
				const userInfoStr = uni.getStorageSync('userInfo')
				const token = uni.getStorageSync('token')
				let userInfo = null

				if (userInfoStr) {
					try {
						// 如果是字符串，尝试解析
						if (typeof userInfoStr === 'string') {
							const parsed = JSON.parse(userInfoStr)
							// 检查是否是登录响应格式
							if (parsed.code === 200 && parsed.data) {
								userInfo = parsed.data
							} else {
								userInfo = parsed
							}
						} else {
							// 如果不是字符串，直接使用
							userInfo = userInfoStr
						}
						console.log("保存的用户信息:", JSON.stringify(userInfo))
					} catch (e) {
						console.error('解析用户信息失败', e)
						// 解析失败时，尝试直接使用
						userInfo = userInfoStr
					}
				}

				const pages = getCurrentPages()
				const currentPage = pages.length ? pages[pages.length - 1].route : ''
				console.log('当前页面路径:', currentPage)

				// 白名单页面不需要登录
				const whiteList = [
					'pages/login/login',
					'pages/login/tech-login',
					'pages/login/customer-login',
					'pages/face-valid/face-valid',
					'pages/my-info/my-info',
					'pages/pay-public/pay-public'
				]
				if (whiteList.includes(currentPage)) {
					console.log('当前页面在白名单中，不检查登录状态')
					return
				}
				const loginType = uni.getStorageSync('loginType')
				// 检查用户是否已登录 (需要同时验证 userInfo 和 token)
				if (!userInfo || !token || (userInfo && !userInfo.openId && currentPage !== 'pages/pay-public/pay-public')) {
					console.log('用户未登录或登录状态无效，需要跳转到登录页')
					// 清理可能存在的无效登录数据
					if (!token) {
						console.log('未检测到有效token，清理可能存在的无效登录信息')
						uni.removeStorageSync('userInfo')
					}

					// 防止循环跳转，检查当前是否正在跳转到登录页
					const isNavigatingToLogin = uni.getStorageSync('isNavigatingToLogin')
					if (isNavigatingToLogin === 'true') {
						console.log('已经在跳转到登录页，避免循环跳转')
						return
					}

					// 设置标记，表示正在跳转到登录页
					uni.setStorageSync('isNavigatingToLogin', 'true')

					// 使用setTimeout避免在onLaunch中直接跳转可能导致的问题
					setTimeout(() => {
						console.log('准备跳转到登录页')
						// 根据loginType决定跳转到哪个登录页面
						const loginType = uni.getStorageSync('loginType')
						const loginUrl = loginType === 'technician' ? '/pages/login/tech-login' :
							'/pages/login/customer-login'

						uni.reLaunch({
							url: loginUrl,
							success: () => {
								console.log('成功跳转到登录页')
								// 跳转完成后清除标记
								setTimeout(() => {
									uni.removeStorageSync('isNavigatingToLogin')
								}, 1000)
							},
							fail: (err) => {
								console.error('跳转到登录页失败:', err)
								uni.removeStorageSync('isNavigatingToLogin')

								// 如果reLaunch失败，尝试使用navigateTo
								setTimeout(() => {
									uni.navigateTo({
										url: loginUrl,
										success: () => {
											console.log('使用navigateTo成功跳转到登录页')
											setTimeout(() => {
												uni.removeStorageSync(
													'isNavigatingToLogin'
													)
											}, 1000)
										},
										fail: (navErr) => {
											console.error('navigateTo也失败:', navErr)
											uni.removeStorageSync(
												'isNavigatingToLogin')
										}
									})
								}, 500)
							}
						})
					}, 100)
				} else {
					console.log('用户已登录，openId:', userInfo.openId || '未知')

					// 检查用户是否已绑定手机号
					if (!userInfo.phone || userInfo.phone.trim() === '') {
						console.log('用户未绑定手机号，需要跳转到个人信息页面')
						// 防止循环跳转，检查当前是否已经在个人信息页面
						if (currentPage !== 'pages/my-info/my-info') {
							// 显示提示
							uni.showModal({
								title: '提示',
								content: '您尚未绑定手机号，请先绑定手机号',
								showCancel: false,
								success: () => {
									// 跳转到个人信息页面
									uni.navigateTo({
										url: '/pages/my-info/my-info',
										fail: (err) => {
											console.error('跳转到个人信息页面失败:', err)
											// 如果navigateTo失败，尝试使用reLaunch
											uni.reLaunch({
												url: '/pages/my-info/my-info',
												fail: (relaunchErr) => {
													console.error('reLaunch也失败:',
														relaunchErr)
												}
											})
										}
									})
								}
							})
							return
						}
					}

					// // 如果是技师，直接跳转到工作台
					// if (userInfo.role === 'technician' && !currentPage.startsWith('pages/technician/')) {
					// 	console.log('技师用户，跳转到工作台')
					// 	uni.switchTab({
					// 		url: '/pages/technician/home',
					// 		success: () => {
					// 			console.log('成功跳转到技师工作台')
					// 		},
					// 		fail: (err) => {
					// 			console.error('跳转到技师工作台失败:', err)
					// 			// 如果switchTab失败，尝试使用reLaunch
					// 			uni.reLaunch({
					// 				url: '/pages/technician/home',
					// 				success: () => {
					// 					console.log('使用reLaunch成功跳转到技师工作台')
					// 				},
					// 				fail: (relaunchErr) => {
					// 					console.error('reLaunch也失败:', relaunchErr)
					// 				}
					// 			})
					// 		}
					// 	})
					// }
				}
			}
		}
	}
</script>

<style>
	@import "colorui/main.css";
	@import "colorui/icon.css";
</style>
<style lang="scss">
	@import "@/node_modules/uview-ui/index.scss";
</style>